package main

import (
	"fmt"
	"log"
	"os"
	"path/filepath"
	"strings"
	"time"

	"mcp-server/internal/docprocessor"
	"mcp-server/internal/metadata"
	"mcp-server/internal/types"
)

func main() {
	if len(os.Args) < 2 {
		fmt.Println("使用方法: go run main.go <知识库目录路径>")
		fmt.Println("示例: go run main.go ../../docs/样本知识")
		os.Exit(1)
	}

	knowledgeDir := os.Args[1]
	fmt.Printf("=== 增强版知识库处理演示 ===\n")
	fmt.Printf("处理目录: %s\n\n", knowledgeDir)

	// 初始化组件
	docProcessor := docprocessor.NewDocumentProcessor()

	// 创建元数据管理器
	metadataStorageDir := filepath.Join("enhanced_metadata_storage")
	metadataManager := metadata.NewDefaultManager(metadataStorageDir)

	// 统计信息
	var totalFiles, processedFiles, totalChunks int
	var totalProcessTime time.Duration
	startTime := time.Now()

	// 存储增强的向量数据（模拟）
	var enhancedVectorData []EnhancedVectorData

	// 遍历处理文件
	err := filepath.Walk(knowledgeDir, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}

		// 只处理支持的文件类型
		ext := strings.ToLower(filepath.Ext(path))
		if ext != ".md" && ext != ".txt" {
			return nil
		}

		totalFiles++
		fmt.Printf("处理文件 %d: %s\n", totalFiles, path)

		// 1. 提取文档元数据
		fmt.Printf("  1. 提取元数据...")
		docMetadata, err := metadataManager.ProcessFile(path)
		if err != nil {
			fmt.Printf(" 失败: %v\n", err)
			return nil
		}
		fmt.Printf(" 完成 (质量: %.1f, 置信度: %.1f)\n", docMetadata.Quality, docMetadata.Confidence)

		// 2. 文档分片处理
		fmt.Printf("  2. 文档分片...")
		fileStartTime := time.Now()
		result, err := docProcessor.ProcessFile(path)
		if err != nil {
			fmt.Printf(" 失败: %v\n", err)
			return nil
		}
		fileProcessTime := time.Since(fileStartTime)
		totalProcessTime += fileProcessTime
		fmt.Printf(" 完成 (%d个分片, %v)\n", len(result.Chunks), fileProcessTime)

		// 3. 创建增强的向量数据
		fmt.Printf("  3. 创建增强向量数据...")

		for _, chunk := range result.Chunks {
			// 创建增强的元数据
			enhancedMetadata := createEnhancedMetadata(chunk, docMetadata, path)

			// 模拟向量生成（实际应用中这里会调用向量化服务）
			mockVector := generateMockVector(chunk.Content)

			// 创建增强的向量数据
			vectorData := EnhancedVectorData{
				ID:       chunk.ID,
				Vector:   mockVector,
				Content:  chunk.Content,
				Metadata: enhancedMetadata,
				ChunkInfo: ChunkInfo{
					StartLine:   chunk.StartLine,
					EndLine:     chunk.EndLine,
					SemanticTag: getSemanticTag(chunk),
					ContentType: getContentType(chunk),
					Index:       chunk.ChunkIndex,
				},
				DocumentInfo: DocumentInfo{
					Title:      docMetadata.Title,
					Author:     docMetadata.Author,
					Category:   docMetadata.Category,
					Quality:    docMetadata.Quality,
					Confidence: docMetadata.Confidence,
					Keywords:   docMetadata.Keywords,
					Summary:    docMetadata.Summary,
				},
				ProcessedAt: time.Now(),
			}

			enhancedVectorData = append(enhancedVectorData, vectorData)
			totalChunks++
		}

		fmt.Printf(" 完成 (%d个增强向量)\n", len(result.Chunks))

		processedFiles++
		fmt.Printf("  ✓ 文件处理完成\n\n")
		return nil
	})

	if err != nil {
		log.Fatalf("遍历目录失败: %v", err)
	}

	// 输出统计信息
	totalTime := time.Since(startTime)
	fmt.Printf("=== 处理完成 ===\n")
	fmt.Printf("总文件数: %d\n", totalFiles)
	fmt.Printf("成功处理: %d\n", processedFiles)
	fmt.Printf("总分片数: %d\n", totalChunks)
	fmt.Printf("总耗时: %v\n", totalTime)
	fmt.Printf("平均每文件: %v\n", totalTime/time.Duration(max(processedFiles, 1)))
	fmt.Printf("文档处理耗时: %v\n", totalProcessTime)

	// 展示元数据统计
	fmt.Printf("\n=== 元数据统计 ===\n")
	stats, err := metadataManager.GetStatistics()
	if err != nil {
		fmt.Printf("获取元数据统计失败: %v\n", err)
	} else {
		fmt.Printf("平均质量评分: %.2f\n", stats["average_quality"])
		fmt.Printf("平均置信度: %.2f\n", stats["average_confidence"])
		fmt.Printf("文档分类分布: %v\n", stats["categories"])
		fmt.Printf("语言分布: %v\n", stats["languages"])
	}

	// 展示增强向量数据示例
	fmt.Printf("\n=== 增强向量数据示例 ===\n")
	if len(enhancedVectorData) > 0 {
		sample := enhancedVectorData[0]
		fmt.Printf("向量ID: %s\n", sample.ID)
		fmt.Printf("内容长度: %d 字符\n", len([]rune(sample.Content)))
		fmt.Printf("向量维度: %d\n", len(sample.Vector))
		fmt.Printf("文档标题: %s\n", sample.DocumentInfo.Title)
		fmt.Printf("文档作者: %s\n", sample.DocumentInfo.Author)
		fmt.Printf("文档分类: %s\n", sample.DocumentInfo.Category)
		fmt.Printf("分片语义标签: %s\n", sample.ChunkInfo.SemanticTag)
		fmt.Printf("元数据字段数: %d\n", len(sample.Metadata))

		fmt.Printf("\n元数据字段:\n")
		for key, value := range sample.Metadata {
			fmt.Printf("  %s: %v\n", key, value)
		}
	}

	// 模拟搜索功能演示
	fmt.Printf("\n=== 增强搜索功能演示 ===\n")
	demonstrateEnhancedSearch(enhancedVectorData)

	fmt.Printf("\n=== 演示完成 ===\n")
	fmt.Printf("增强版向量化处理完成！\n")
	fmt.Printf("生成了 %d 个包含丰富元数据的向量\n", len(enhancedVectorData))
}

// EnhancedVectorData 增强的向量数据结构
type EnhancedVectorData struct {
	ID           string                 `json:"id"`
	Vector       []float32              `json:"vector"`
	Content      string                 `json:"content"`
	Metadata     map[string]interface{} `json:"metadata"`
	ChunkInfo    ChunkInfo              `json:"chunk_info"`
	DocumentInfo DocumentInfo           `json:"document_info"`
	ProcessedAt  time.Time              `json:"processed_at"`
}

// ChunkInfo 分片信息
type ChunkInfo struct {
	StartLine   int    `json:"start_line"`
	EndLine     int    `json:"end_line"`
	SemanticTag string `json:"semantic_tag"`
	ContentType string `json:"content_type"`
	Index       int    `json:"index"`
}

// DocumentInfo 文档信息
type DocumentInfo struct {
	Title      string   `json:"title"`
	Author     string   `json:"author"`
	Category   string   `json:"category"`
	Quality    float64  `json:"quality"`
	Confidence float64  `json:"confidence"`
	Keywords   []string `json:"keywords"`
	Summary    string   `json:"summary"`
}

// createEnhancedMetadata 创建增强的元数据
func createEnhancedMetadata(chunk *types.TextChunk, docMeta *metadata.DocumentMetadata, filePath string) map[string]interface{} {
	// 基础分片元数据
	metadata := map[string]interface{}{
		"file_path":      filePath,
		"file_name":      filepath.Base(filePath),
		"chunk_id":       chunk.ID,
		"start_line":     chunk.StartLine,
		"end_line":       chunk.EndLine,
		"semantic_tag":   getSemanticTag(chunk),
		"content_type":   getContentType(chunk),
		"chunk_index":    chunk.ChunkIndex,
		"content_length": len([]rune(chunk.Content)),
	}

	// 添加文档级元数据
	if docMeta != nil {
		metadata["doc_title"] = docMeta.Title
		metadata["doc_author"] = docMeta.Author
		metadata["doc_category"] = docMeta.Category
		metadata["doc_language"] = docMeta.Language
		metadata["doc_quality"] = docMeta.Quality
		metadata["doc_confidence"] = docMeta.Confidence
		metadata["doc_word_count"] = docMeta.WordCount
		metadata["doc_created_at"] = docMeta.CreatedAt.Format(time.RFC3339)
		metadata["doc_modified_at"] = docMeta.ModifiedAt.Format(time.RFC3339)

		// 关键词（转换为字符串便于搜索）
		if len(docMeta.Keywords) > 0 {
			metadata["doc_keywords"] = strings.Join(docMeta.Keywords, ",")
		}

		// 标题层级（转换为字符串）
		if len(docMeta.Headings) > 0 {
			metadata["doc_headings"] = strings.Join(docMeta.Headings, "|")
		}

		// 摘要（截取前200字符）
		if docMeta.Summary != "" {
			summary := docMeta.Summary
			if len([]rune(summary)) > 200 {
				summary = string([]rune(summary)[:200]) + "..."
			}
			metadata["doc_summary"] = summary
		}
	}

	// 添加处理时间戳
	metadata["processed_at"] = time.Now().Format(time.RFC3339)
	metadata["metadata_version"] = "1.0"

	return metadata
}

// generateMockVector 生成模拟向量（实际应用中应该调用真实的向量化服务）
func generateMockVector(content string) []float32 {
	// 基于内容生成简单的特征向量
	vector := make([]float32, 768) // 768维向量

	// 基于内容长度和字符特征生成向量
	contentLength := float32(len([]rune(content)))
	for i := range vector {
		// 简单的特征计算
		vector[i] = float32(i%10) * 0.1 * (contentLength / 1000.0)
		if i%2 == 0 {
			vector[i] *= -1
		}
	}

	return vector
}

// demonstrateEnhancedSearch 演示增强搜索功能
func demonstrateEnhancedSearch(vectorData []EnhancedVectorData) {
	if len(vectorData) == 0 {
		fmt.Println("没有向量数据可供搜索演示")
		return
	}

	fmt.Println("模拟基于元数据的增强搜索:")

	// 1. 按文档分类搜索
	categoryCount := make(map[string]int)
	for _, data := range vectorData {
		if data.DocumentInfo.Category != "" {
			categoryCount[data.DocumentInfo.Category]++
		}
	}

	fmt.Printf("1. 按文档分类统计:\n")
	for category, count := range categoryCount {
		fmt.Printf("   %s: %d 个分片\n", category, count)
	}

	// 2. 按质量评分过滤
	highQualityCount := 0
	for _, data := range vectorData {
		if data.DocumentInfo.Quality >= 70.0 {
			highQualityCount++
		}
	}
	fmt.Printf("2. 高质量文档分片 (质量>=70): %d 个\n", highQualityCount)

	// 3. 按作者统计
	authorCount := make(map[string]int)
	for _, data := range vectorData {
		if data.DocumentInfo.Author != "" {
			authorCount[data.DocumentInfo.Author]++
		}
	}

	fmt.Printf("3. 按作者统计:\n")
	for author, count := range authorCount {
		fmt.Printf("   %s: %d 个分片\n", author, count)
	}

	// 4. 展示搜索优势
	fmt.Printf("4. 增强搜索的优势:\n")
	fmt.Printf("   - 可以按文档质量过滤结果\n")
	fmt.Printf("   - 可以按作者、分类等维度筛选\n")
	fmt.Printf("   - 可以结合语义标签提高搜索精度\n")
	fmt.Printf("   - 可以利用文档摘要和关键词增强相关性\n")
}

// getSemanticTag 获取语义标签
func getSemanticTag(chunk *types.TextChunk) string {
	// 基于内容分析生成语义标签
	content := strings.ToLower(chunk.Content)

	if strings.Contains(content, "第") && (strings.Contains(content, "章") || strings.Contains(content, "条") || strings.Contains(content, "款")) {
		return "法规条款"
	}
	if strings.Contains(content, "管理") || strings.Contains(content, "制度") {
		return "管理制度"
	}
	if strings.Contains(content, "责任") || strings.Contains(content, "义务") {
		return "责任义务"
	}
	if strings.Contains(content, "监督") || strings.Contains(content, "检查") {
		return "监督检查"
	}
	if strings.Contains(content, "#") {
		return "标题"
	}

	return "正文内容"
}

// getContentType 获取内容类型
func getContentType(chunk *types.TextChunk) string {
	content := strings.TrimSpace(chunk.Content)

	if strings.HasPrefix(content, "#") {
		return "标题"
	}
	if strings.Contains(content, "第") && strings.Contains(content, "条") {
		return "条款"
	}
	if len([]rune(content)) < 50 {
		return "短文本"
	}
	if len([]rune(content)) > 500 {
		return "长文本"
	}

	return "段落"
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
